!===================Faz a permutação de números========================
!Esse programa requer um arquivo perm_in.dat com a ordem anterior
!a das permutaçoes que você quer gerar. O arquivo perm_out.dat NÃO
!deve existir

PROGRAM exer03

!======================================================================

IMPLICIT NONE

!=======================Declaração de variáveis========================

      INTEGER, ALLOCATABLE, DIMENSION(:) :: leitura
      INTEGER :: I, N, fat

!===========================Leitura de dados===========================

      WRITE(*,*) "Entre com o N"
      READ(*,*) N

!==============Abertura de arquivo e alocação de memória===============

      OPEN(UNIT=10, FILE='perm_in.dat', STATUS='old')
      OPEN(UNIT=20, FILE='perm_out.dat', STATUS='new', POSITION='append')
      
      ALLOCATE(leitura(N+1))

!=========================Chamada da subrotina=========================

      !Calcula o fatorial que será usado como limite no proximo loop
      fat = 1
      DO I=1,N
            fat = fat*I
      END DO
      !Lê linha por linha do arquivo de entrada e permuta a partir de
      !cada linha. Chama a subrotina para cada linha
      DO I=1,fat
            READ(10,*) leitura
            CALL permut(leitura,N)
      END DO

!===========================Desaloca memória===========================

      DEALLOCATE(leitura)

!======================================================================

END PROGRAM exer03

!======================================================================


!=================Subrotina que permuta dado o vetor===================

!Subrotina recebe o vetor no qual incluirá o próximo número e fará
!as permutações. Também recebe N (número inicial de valores fora a
!paridade)
SUBROUTINE permut (vet,N)

      IMPLICIT NONE

      INTEGER :: N, I, J, flag
      INTEGER, DIMENSION(N+1) :: vet
      INTEGER, DIMENSION(N+2) :: temp

      DO J=1,(N+1)
            !Inicializa o vetor temporário
            temp = 0
            !Verifica a paridade
            IF (vet(N+1) == 1) THEN
                  temp(N+2) = (-1)**(J+1)
            ELSE
                  temp(N+2) = (-1)**J
            END IF
            !Coloca o valor de N+1 na posição que depende de J
            temp(N+2-J) = (N+1)
            flag = 0

            !Loop que faz as permutações
            DO I=1,N
                  IF (temp(I) /= (N+1) .AND. flag == 0) THEN
                        !Para os valores diferentes e anteriores a N+1
                        temp(I) = vet(I)
                  ELSE
                        !Para os valores após o N+1
                        temp(I+1) = vet(I)
                        flag = 1
                  END IF
            END DO

            !Escreve no arquivo de saída as permutações geradas nesse loop
            WRITE(20,*) temp
      END DO

END SUBROUTINE permut

!======================================================================
